home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 39 / Amiga Format CD39 (1999-04-13)(Future Publishing)(GB)[!][issue 1999-05].iso / -seriously_amiga- / graphics / ripley / source / getblk.c < prev    next >
C/C++ Source or Header  |  1999-03-02  |  13KB  |  571 lines
  1. /* getblk.c, DCT block decoding                                             */
  2.  
  3. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  4.  
  5. /*
  6.  * Disclaimer of Warranty
  7.  *
  8.  * These software programs are available to the user without any license fee or
  9.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  10.  * any and all warranties, whether express, implied, or statuary, including any
  11.  * implied warranties or merchantability or of fitness for a particular
  12.  * purpose.  In no event shall the copyright-holder be liable for any
  13.  * incidental, punitive, or consequential damages of any kind whatsoever
  14.  * arising from the use of these programs.
  15.  *
  16.  * This disclaimer of warranty extends to the user of these programs and user's
  17.  * customers, employees, agents, transferees, successors, and assigns.
  18.  *
  19.  * The MPEG Software Simulation Group does not represent or warrant that the
  20.  * programs furnished hereunder are free of infringement of any third-party
  21.  * patents.
  22.  *
  23.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  24.  * are subject to royalty fees to patent holders.  Many of these patents are
  25.  * general enough such that they are unavoidable regardless of implementation
  26.  * design.
  27.  *
  28.  */
  29.  
  30. #include <stdio.h>
  31.  
  32. #include "config.h"
  33. #include "global.h"
  34.  
  35.  
  36. /* defined in getvlc.h */
  37. typedef struct {
  38.   char run, level, len;
  39. } DCTtab;
  40.  
  41. extern DCTtab DCTtabfirst[],DCTtabnext[],DCTtab0[],DCTtab1[];
  42. extern DCTtab DCTtab2[],DCTtab3[],DCTtab4[],DCTtab5[],DCTtab6[];
  43. extern DCTtab DCTtab0a[],DCTtab1a[];
  44.  
  45.  
  46. /* decode one intra coded MPEG-1 block */
  47.  
  48. void Decode_MPEG1_Intra_Block(comp,dc_dct_pred)
  49. int comp;
  50. int dc_dct_pred[];
  51. {
  52.   int val, i, j, sign;
  53.   unsigned int code;
  54.   DCTtab *tab;
  55.   short *bp;
  56.  
  57.   bp = ld->block[comp];
  58.  
  59.   /* ISO/IEC 11172-2 section 2.4.3.7: Block layer. */
  60.   /* decode DC coefficients */
  61.   if (comp<4)
  62.     bp[0] = (dc_dct_pred[0]+=Get_Luma_DC_dct_diff()) << 3;
  63.   else if (comp==4)
  64.     bp[0] = (dc_dct_pred[1]+=Get_Chroma_DC_dct_diff()) << 3;
  65.   else
  66.     bp[0] = (dc_dct_pred[2]+=Get_Chroma_DC_dct_diff()) << 3;
  67.  
  68.   if (Fault_Flag) return;
  69.  
  70.   /* D-pictures do not contain AC coefficients */
  71.   if(picture_coding_type == D_TYPE)
  72.     return;
  73.  
  74.   /* decode AC coefficients */
  75.   for (i=1; ; i++)
  76.   {
  77.     code = Show_Bits(16);
  78.     if (code>=16384)
  79.       tab = &DCTtabnext[(code>>12)-4];
  80.     else if (code>=1024)
  81.       tab = &DCTtab0[(code>>8)-4];
  82.     else if (code>=512)
  83.       tab = &DCTtab1[(code>>6)-8];
  84.     else if (code>=256)
  85.       tab = &DCTtab2[(code>>4)-16];
  86.     else if (code>=128)
  87.       tab = &DCTtab3[(code>>3)-16];
  88.     else if (code>=64)
  89.       tab = &DCTtab4[(code>>2)-16];
  90.     else if (code>=32)
  91.       tab = &DCTtab5[(code>>1)-16];
  92.     else if (code>=16)
  93.       tab = &DCTtab6[code-16];
  94.     else
  95.     {
  96.       if (!Quiet_Flag)
  97.         printf("invalid Huffman code in Decode_MPEG1_Intra_Block()\n");
  98.       Fault_Flag = 1;
  99.       return;
  100.     }
  101.  
  102.     Flush_Buffer(tab->len);
  103.  
  104.     if (tab->run==64) /* end_of_block */
  105.       return;
  106.  
  107.     if (tab->run==65) /* escape */
  108.     {
  109.       i+= Get_Bits(6);
  110.  
  111.       val = Get_Bits(8);
  112.       if (val==0)
  113.         val = Get_Bits(8);
  114.       else if (val==128)
  115.         val = Get_Bits(8) - 256;
  116.       else if (val>128)
  117.         val -= 256;
  118.  
  119.       if((sign = (val<0)))
  120.         val = -val;
  121.     }
  122.     else
  123.     {
  124.       i+= tab->run;
  125.       val = tab->level;
  126.       sign = Get_Bits(1);
  127.     }
  128.  
  129.     if (i>=64)
  130.     {
  131.       if (!Quiet_Flag)
  132.         fprintf(stderr,"DCT coeff index (i) out of bounds (intra)\n");
  133.       Fault_Flag = 1;
  134.       return;
  135.     }
  136.  
  137.     j = scan[ZIG_ZAG][i];
  138.     val = (val*ld->quantizer_scale*ld->intra_quantizer_matrix[j]) >> 3;
  139.  
  140.     /* mismatch control ('oddification') */
  141.     if (val!=0) /* should always be true, but it's not guaranteed */
  142.       val = (val-1) | 1; /* equivalent to: if ((val&1)==0) val = val - 1; */
  143.  
  144.     /* saturation */
  145.     if (!sign)
  146.       bp[j] = (val>2047) ?  2047 :  val; /* positive */
  147.     else
  148.       bp[j] = (val>2048) ? -2048 : -val; /* negative */
  149.   }
  150. }
  151.  
  152.  
  153. /* decode one non-intra coded MPEG-1 block */
  154.  
  155. void Decode_MPEG1_Non_Intra_Block(comp)
  156. int comp;
  157. {
  158.   int val, i, j, sign;
  159.   unsigned int code;
  160.   DCTtab *tab;
  161.   short *bp;
  162.  
  163.   bp = ld->block[comp];
  164.  
  165.   /* decode AC coefficients */
  166.   for (i=0; ; i++)
  167.   {
  168.     code = Show_Bits(16);
  169.     if (code>=16384)
  170.     {
  171.       if (i==0)
  172.         tab = &DCTtabfirst[(code>>12)-4];
  173.       else
  174.         tab = &DCTtabnext[(code>>12)-4];
  175.     }
  176.     else if (code>=1024)
  177.       tab = &DCTtab0[(code>>8)-4];
  178.     else if (code>=512)
  179.       tab = &DCTtab1[(code>>6)-8];
  180.     else if (code>=256)
  181.       tab = &DCTtab2[(code>>4)-16];
  182.     else if (code>=128)
  183.       tab = &DCTtab3[(code>>3)-16];
  184.     else if (code>=64)
  185.       tab = &DCTtab4[(code>>2)-16];
  186.     else if (code>=32)
  187.       tab = &DCTtab5[(code>>1)-16];
  188.     else if (code>=16)
  189.       tab = &DCTtab6[code-16];
  190.     else
  191.     {
  192.       if (!Quiet_Flag)
  193.         printf("invalid Huffman code in Decode_MPEG1_Non_Intra_Block()\n");
  194.       Fault_Flag = 1;
  195.       return;
  196.     }
  197.  
  198.     Flush_Buffer(tab->len);
  199.  
  200.     if (tab->run==64) /* end_of_block */
  201.       return;
  202.  
  203.     if (tab->run==65) /* escape */
  204.     {
  205.       i+= Get_Bits(6);
  206.  
  207.       val = Get_Bits(8);
  208.       if (val==0)
  209.         val = Get_Bits(8);
  210.       else if (val==128)
  211.         val = Get_Bits(8) - 256;
  212.       else if (val>128)
  213.         val -= 256;
  214.  
  215.       if((sign = (val<0)))
  216.         val = -val;
  217.     }
  218.     else
  219.     {
  220.       i+= tab->run;
  221.       val = tab->level;
  222.       sign = Get_Bits(1);
  223.     }
  224.  
  225.     if (i>=64)
  226.     {
  227.       if (!Quiet_Flag)
  228.         fprintf(stderr,"DCT coeff index (i) out of bounds (inter)\n");
  229.       Fault_Flag = 1;
  230.       return;
  231.     }
  232.  
  233.     j = scan[ZIG_ZAG][i];
  234.     val = (((val<<1)+1)*ld->quantizer_scale*ld->non_intra_quantizer_matrix[j]) >> 4;
  235.  
  236.     /* mismatch control ('oddification') */
  237.     if (val!=0) /* should always be true, but it's not guaranteed */
  238.       val = (val-1) | 1; /* equivalent to: if ((val&1)==0) val = val - 1; */
  239.  
  240.     /* saturation */
  241.     if (!sign)
  242.       bp[j] = (val>2047) ?  2047 :  val; /* positive */
  243.     else
  244.       bp[j] = (val>2048) ? -2048 : -val; /* negative */
  245.   }
  246. }
  247.  
  248.  
  249. /* decode one intra coded MPEG-2 block */
  250.  
  251. void Decode_MPEG2_Intra_Block(comp,dc_dct_pred)
  252. int comp;
  253. int dc_dct_pred[];
  254. {
  255.   int val, i, j, sign, nc, cc, run;
  256.   unsigned int code;
  257.   DCTtab *tab;
  258.   short *bp;
  259.   int *qmat;
  260.   struct layer_data *ld1;
  261.  
  262.   /* with data partitioning, data always goes to base layer */
  263.   ld1 = (ld->scalable_mode==SC_DP) ? &base : ld;
  264.   bp = ld1->block[comp];
  265.  
  266.   if (base.scalable_mode==SC_DP)
  267.     if (base.priority_breakpoint<64)
  268.       ld = &enhan;
  269.     else
  270.       ld = &base;
  271.  
  272.   cc = (comp<4) ? 0 : (comp&1)+1;
  273.  
  274.   qmat = (comp<4 || chroma_format==CHROMA420)
  275.          ? ld1->intra_quantizer_matrix
  276.          : ld1->chroma_intra_quantizer_matrix;
  277.  
  278.   /* ISO/IEC 13818-2 section 7.2.1: decode DC coefficients */
  279.   if (cc==0)
  280.     val = (dc_dct_pred[0]+= Get_Luma_DC_dct_diff());
  281.   else if (cc==1)
  282.     val = (dc_dct_pred[1]+= Get_Chroma_DC_dct_diff());
  283.   else
  284.     val = (dc_dct_pred[2]+= Get_Chroma_DC_dct_diff());
  285.  
  286.   if (Fault_Flag) return;
  287.  
  288.   bp[0] = val << (3-intra_dc_precision);
  289.  
  290.   nc=0;
  291.  
  292. #ifdef TRACE
  293.   if (Trace_Flag)
  294.     printf("DCT(%d)i:",comp);
  295. #endif /* TRACE */
  296.  
  297.   /* decode AC coefficients */
  298.   for (i=1; ; i++)
  299.   {
  300.     code = Show_Bits(16);
  301.     if (code>=16384 && !intra_vlc_format)
  302.       tab = &DCTtabnext[(code>>12)-4];
  303.     else if (code>=1024)
  304.     {
  305.       if (intra_vlc_format)
  306.         tab = &DCTtab0a[(code>>8)-4];
  307.       else
  308.         tab = &DCTtab0[(code>>8)-4];
  309.     }
  310.     else if (code>=512)
  311.     {
  312.       if (intra_vlc_format)
  313.         tab = &DCTtab1a[(code>>6)-8];
  314.       else
  315.         tab = &DCTtab1[(code>>6)-8];
  316.     }
  317.     else if (code>=256)
  318.       tab = &DCTtab2[(code>>4)-16];
  319.     else if (code>=128)
  320.       tab = &DCTtab3[(code>>3)-16];
  321.     else if (code>=64)
  322.       tab = &DCTtab4[(code>>2)-16];
  323.     else if (code>=32)
  324.       tab = &DCTtab5[(code>>1)-16];
  325.     else if (code>=16)
  326.       tab = &DCTtab6[code-16];
  327.     else
  328.     {
  329.       if (!Quiet_Flag)
  330.         printf("invalid Huffman code in Decode_MPEG2_Intra_Block()\n");
  331.       Fault_Flag = 1;
  332.       return;
  333.     }
  334.  
  335.     Flush_Buffer(tab->len);
  336.  
  337. #ifdef TRACE
  338.     if (Trace_Flag)
  339.     {
  340.       printf(" (");
  341.       Print_Bits(code,16,tab->len);
  342.     }
  343. #endif /* TRACE */
  344.  
  345.     if (tab->run==64) /* end_of_block */
  346.     {
  347. #ifdef TRACE
  348.       if (Trace_Flag)
  349.         printf("): EOB\n");
  350. #endif /* TRACE */
  351.       return;
  352.     }
  353.  
  354.     if (tab->run==65) /* escape */
  355.     {
  356. #ifdef TRACE
  357.       if (Trace_Flag)
  358.       {
  359.         putchar(' ');
  360.         Print_Bits(Show_Bits(6),6,6);
  361.       }
  362. #endif /* TRACE */
  363.  
  364.       i+= run = Get_Bits(6);
  365.  
  366. #ifdef TRACE
  367.       if (Trace_Flag)
  368.       {
  369.         putchar(' ');
  370.         Print_Bits(Show_Bits(12),12,12);
  371.       }
  372. #endif /* TRACE */
  373.  
  374.       val = Get_Bits(12);
  375.       if ((val&2047)==0)
  376.       {
  377.         if (!Quiet_Flag)
  378.           printf("invalid escape in Decode_MPEG2_Intra_Block()\n");
  379.         Fault_Flag = 1;
  380.         return;
  381.       }
  382.       if((sign = (val>=2048)))
  383.         val = 4096 - val;
  384.     }
  385.     else
  386.     {
  387.       i+= run = tab->run;
  388.       val = tab->level;
  389.       sign = Get_Bits(1);
  390.  
  391. #ifdef TRACE
  392.       if (Trace_Flag)
  393.         printf("%d",sign);
  394. #endif /* TRACE */
  395.     }
  396.  
  397.     if (i>=64)
  398.     {
  399.       if (!Quiet_Flag)
  400.         fprintf(stderr,"DCT coeff index (i) out of bounds (intra2)\n");
  401.       Fault_Flag = 1;
  402.       return;
  403.     }
  404.  
  405. #ifdef TRACE
  406.     if (Trace_Flag)
  407.       printf("): %d/%d",run,sign ? -val : val);
  408. #endif /* TRACE */
  409.  
  410.     j = scan[ld1->alternate_scan][i];
  411.     val = (val * ld1->quantizer_scale * qmat[j]) >> 4;
  412.     bp[j] = sign ? -val : val;
  413.     nc++;
  414.  
  415.     if (base.scalable_mode==SC_DP && nc==base.priority_breakpoint-63)
  416.       ld = &enhan;
  417.   }
  418. }
  419.  
  420.  
  421. /* decode one non-intra coded MPEG-2 block */
  422.  
  423. void Decode_MPEG2_Non_Intra_Block(comp)
  424. int comp;
  425. {
  426.   int val, i, j, sign, nc, run;
  427.   unsigned int code;
  428.   DCTtab *tab;
  429.   short *bp;
  430.   int *qmat;
  431.   struct layer_data *ld1;
  432.  
  433.   /* with data partitioning, data always goes to base layer */
  434.   ld1 = (ld->scalable_mode==SC_DP) ? &base : ld;
  435.   bp = ld1->block[comp];
  436.  
  437.   if (base.scalable_mode==SC_DP)
  438.     if (base.priority_breakpoint<64)
  439.       ld = &enhan;
  440.     else
  441.       ld = &base;
  442.  
  443.   qmat = (comp<4 || chroma_format==CHROMA420)
  444.          ? ld1->non_intra_quantizer_matrix
  445.          : ld1->chroma_non_intra_quantizer_matrix;
  446.  
  447.   nc = 0;
  448.  
  449. #ifdef TRACE
  450.   if (Trace_Flag)
  451.     printf("DCT(%d)n:",comp);
  452. #endif /* TRACE */
  453.  
  454.   /* decode AC coefficients */
  455.   for (i=0; ; i++)
  456.   {
  457.     code = Show_Bits(16);
  458.     if (code>=16384)
  459.     {
  460.       if (i==0)
  461.         tab = &DCTtabfirst[(code>>12)-4];
  462.       else
  463.         tab = &DCTtabnext[(code>>12)-4];
  464.     }
  465.     else if (code>=1024)
  466.       tab = &DCTtab0[(code>>8)-4];
  467.     else if (code>=512)
  468.       tab = &DCTtab1[(code>>6)-8];
  469.     else if (code>=256)
  470.       tab = &DCTtab2[(code>>4)-16];
  471.     else if (code>=128)
  472.       tab = &DCTtab3[(code>>3)-16];
  473.     else if (code>=64)
  474.       tab = &DCTtab4[(code>>2)-16];
  475.     else if (code>=32)
  476.       tab = &DCTtab5[(code>>1)-16];
  477.     else if (code>=16)
  478.       tab = &DCTtab6[code-16];
  479.     else
  480.     {
  481.       if (!Quiet_Flag)
  482.         printf("invalid Huffman code in Decode_MPEG2_Non_Intra_Block()\n");
  483.       Fault_Flag = 1;
  484.       return;
  485.     }
  486.  
  487.     Flush_Buffer(tab->len);
  488.  
  489. #ifdef TRACE
  490.     if (Trace_Flag)
  491.     {
  492.       printf(" (");
  493.       Print_Bits(code,16,tab->len);
  494.     }
  495. #endif /* TRACE */
  496.  
  497.     if (tab->run==64) /* end_of_block */
  498.     {
  499. #ifdef TRACE
  500.       if (Trace_Flag)
  501.         printf("): EOB\n");
  502. #endif /* TRACE */
  503.       return;
  504.     }
  505.  
  506.     if (tab->run==65) /* escape */
  507.     {
  508. #ifdef TRACE
  509.       if (Trace_Flag)
  510.       {
  511.         putchar(' ');
  512.         Print_Bits(Show_Bits(6),6,6);
  513.       }
  514. #endif /* TRACE */
  515.  
  516.       i+= run = Get_Bits(6);
  517.  
  518. #ifdef TRACE
  519.       if (Trace_Flag)
  520.       {
  521.         putchar(' ');
  522.         Print_Bits(Show_Bits(12),12,12);
  523.       }
  524. #endif /* TRACE */
  525.  
  526.       val = Get_Bits(12);
  527.       if ((val&2047)==0)
  528.       {
  529.         if (!Quiet_Flag)
  530.           printf("invalid escape in Decode_MPEG2_Intra_Block()\n");
  531.         Fault_Flag = 1;
  532.         return;
  533.       }
  534.       if((sign = (val>=2048)))
  535.         val = 4096 - val;
  536.     }
  537.     else
  538.     {
  539.       i+= run = tab->run;
  540.       val = tab->level;
  541.       sign = Get_Bits(1);
  542.  
  543. #ifdef TRACE
  544.       if (Trace_Flag)
  545.         printf("%d",sign);
  546. #endif /* TRACE */
  547.     }
  548.  
  549.     if (i>=64)
  550.     {
  551.       if (!Quiet_Flag)
  552.         fprintf(stderr,"DCT coeff index (i) out of bounds (inter2)\n");
  553.       Fault_Flag = 1;
  554.       return;
  555.     }
  556.  
  557. #ifdef TRACE
  558.     if (Trace_Flag)
  559.       printf("): %d/%d",run,sign?-val:val);
  560. #endif /* TRACE */
  561.  
  562.     j = scan[ld1->alternate_scan][i];
  563.     val = (((val<<1)+1) * ld1->quantizer_scale * qmat[j]) >> 5;
  564.     bp[j] = sign ? -val : val;
  565.     nc++;
  566.  
  567.     if (base.scalable_mode==SC_DP && nc==base.priority_breakpoint-63)
  568.       ld = &enhan;
  569.   }
  570. }
  571.